home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 008 / grepcode.lqr / grepcode.lbr / GREP.C next >
Encoding:
C/C++ Source or Header  |  2011-01-27  |  4.1 KB  |  310 lines
  1. /*    GREP.c: A generalized regular expression parser.
  2.  */
  3.  
  4. #include "stdio.h"
  5. #include "tools.h"
  6.  
  7. #define MAXLINE 255
  8. #define MAX_EXPR 64
  9.  
  10. int     vflag, yflag, cflag, lflag, nflag, hflag, fflag;
  11.  
  12. main(argc,argv)
  13. int    argc;
  14. char    **argv;
  15. {
  16.     int    i, j, linenum, count;
  17.  
  18.     int    line[MAXLINE];
  19.     int    numfiles;
  20.     FILE    *stream;
  21.     int    exprc;
  22.  
  23.     TOKEN    *exprv[MAX_EXPR];
  24.  
  25.     i = 1;
  26.  
  27.     if (argc <2)
  28.         abort( pr_usage(1) );
  29.  
  30.     if ( *argv[i] == '-')
  31.     {
  32.  
  33.         expand_sw( argv[i++] );
  34.  
  35.         if ( i == argc )
  36.             abort( pr_usage(1) );
  37.     }
  38.  
  39.     if ( (exprc = get_expr( exprv, MAX_EXPR, &argv[i++])) == 0 )
  40.         abort ( pr_usage(2) );
  41.  
  42.     numfiles = argc - i;
  43.  
  44.     do
  45.     {
  46.         if ( numfiles)
  47.         {
  48.             stream = fopen( argv[i], "r");
  49.  
  50.             if (stream == NULL)
  51.             {
  52.                 fprintf(stderr, "Can't open %s\n", argv[i]);
  53.                 continue;
  54.             }
  55.         }
  56.         else
  57.         {
  58.             stream = stdin;
  59.         }
  60.  
  61.         count = 0;
  62.         linenum = 1;
  63.  
  64.         while ( fgets(line, MAXLINE, stream) )
  65.         {
  66.             if (yflag )
  67.                 stoupper(line);
  68.  
  69.             for ( j = exprc ; --j >= 0 ; )
  70.             {
  71.                 if ( matchs(line , exprv[j]) )
  72.                 {
  73.                     count++;
  74.                     pr_match(linenum, line, argv[i], 1, numfiles);
  75.                 }
  76.                 else
  77.                 {
  78.                     pr_match(linenum, line, argv[i], 0, numfiles);
  79.                 }
  80.  
  81.                 linenum++;
  82.                 cntrl_c();
  83.             }
  84.             if( lflag && count )
  85.                 break;
  86.         }
  87.         pr_count( numfiles, argv[i], count );
  88.         fclose (stream);
  89.  
  90.     } while (++i < argc);
  91.     
  92.     abort();
  93. }
  94.  
  95.  
  96. pr_count( fcount, fname, count)
  97. int    fcount, count;
  98. char    *fname;
  99. {
  100.     
  101.     if (!cflag)
  102.         return;
  103.  
  104.     if (fcount > 1)
  105.         printf("%-12s: ", fname );
  106.     
  107.     printf( "%d\n", count );
  108. }
  109.  
  110.  
  111. pr_match(linenum, line, fname, match, numfiles)
  112. int    linenum, match;
  113. char    *line, *fname;
  114. {
  115.  
  116.     char    buf[80];
  117.  
  118.     if (cflag)
  119.         return;
  120.  
  121.     if ( (vflag && !match) || (!vflag && match) )
  122.     {
  123.         if (!hflag && ( (numfiles >1) || lflag) )
  124.             printf("%s%s", fname, lflag ? "\n" : ":" );
  125.  
  126.         if (nflag)
  127.             printf("%03d:", linenum );
  128.  
  129.         if (!lflag)
  130.             printf("%s", line );
  131.     }
  132. }
  133.  
  134.  
  135. pr_usage(num)
  136. int    num;
  137. {
  138.  
  139. #ifdef DEBUG
  140.     fprintf(stderr, "%d ", num);
  141. #endif
  142.     fprintf(stderr,"usage: grep [-cefhlnvy] [expression] <files ...>\n");
  143. }
  144.  
  145.  
  146. abort()
  147. {    
  148.     exit();
  149. }
  150.  
  151.  
  152. expand_sw( str )
  153. char    *str;
  154. {
  155.  
  156.  
  157.     vflag = 0;
  158.     cflag = 0;
  159.     lflag = 0;
  160.     nflag = 0;
  161.     hflag = 0;
  162.     fflag = 0;
  163.     yflag = 0;
  164.  
  165.     while (*str)
  166.     {
  167.         switch ( toupper(*str))
  168.         {
  169.         case '-':
  170.         case 'E':
  171.             break;
  172.  
  173.         case 'C':
  174.             cflag = 1;
  175.             break;
  176.  
  177.         case 'F':
  178.             fflag = 1;
  179.             break;
  180.  
  181.         case 'H':
  182.             hflag = 1;
  183.             break;
  184.  
  185.         case 'L':
  186.             lflag = 1;
  187.             break;
  188.  
  189.         case 'N':
  190.             nflag = 1;
  191.             break;
  192.  
  193.         case 'V':
  194.             vflag = 1;
  195.             break;
  196.  
  197.         case 'Y':
  198.             yflag = 1;
  199.             break;
  200.  
  201.         default:
  202.             pr_usage(3);
  203.             abort();
  204.             break;
  205.         }
  206.  
  207.         str++;
  208.     }
  209. }
  210.  
  211.  
  212. int do_or( lp, expr, maxi )
  213. char    *lp;
  214. TOKEN    **expr;
  215. int    maxi;
  216. {
  217.  
  218.     int    found;
  219.     TOKEN    *pat;
  220.     char    *op;
  221.  
  222.     found = 0;
  223.  
  224.     if( yflag )
  225.         stoupper( lp );
  226.  
  227.     while (op = in_string(OR_SYM, lp) )
  228.     {
  229.         if(found <= maxi && (pat = makepat(lp, OR_SYM)) )
  230.         {
  231.             *expr++ = pat;
  232.             found++;
  233.         }
  234.         lp = ++op;
  235.  
  236.         if ( pat == 0 )
  237.             goto fatal_err;
  238.     }
  239.  
  240.     if (found <= maxi && (pat = makepat( lp, OR_SYM)) )
  241.     {
  242.         found++;
  243.         *expr = pat;
  244.     }
  245.  
  246.     if ( pat == 0)
  247.     {
  248.         
  249. fatal_err:
  250.         printf("Illegal expression\n");
  251.         exit();
  252.     }
  253.  
  254.     return (found);
  255. }
  256.  
  257.  
  258. get_expr( expr, maxi, defexpr)
  259. TOKEN    *expr[];
  260. int    maxi;
  261. char    **defexpr;
  262. {
  263.     FILE    *stream;
  264.     int    count;
  265.  
  266.     char    line[MAXLINE];
  267.  
  268. #ifdef DEBUF
  269.     int    i;
  270. #endif
  271.  
  272.     count = 0;
  273.  
  274.     if ( fflag )
  275.     {
  276.         if ( (stream = fopen(*defexpr, "r")) == NULL )
  277.         {
  278.             fprintf(stderr, "Can't open %s\n", *defexpr);
  279.             abort();
  280.         }
  281.  
  282.         while ( (maxi - count) && fgets(line, MAXLINE, stream) )
  283.         {
  284.             count += do_or(line, &expr[count], maxi - count );
  285.         }
  286.  
  287.         fclose (stream);
  288.     }
  289.     else
  290.     {
  291.         if ( count += do_or( *defexpr, &expr[count], maxi - count))
  292.             *defexpr = " ";
  293.     }
  294.  
  295. #ifdef DEBUG
  296.     for (i = count; --i >= 0; )
  297.     {
  298.         pr_tok(expr[i]);
  299.         printf("--------------------------------------\n");
  300.     }
  301. #endif
  302.     return(count);
  303. }
  304.  
  305.  
  306. cntrl_c()
  307. {
  308. }
  309.  
  310.